Task Scheduling in Multiprocessing Systems - Computer

obs needing to be processed in a manufacturing plant, bank customers waiting to be served by tellers, aircraft waiting for landing clearances, and program tasks to be run on a parallel or distributed computer: What do these situations have in common? They all encounter the scheduling problem that emerges whenever there is a choice concerning the order in which tasks can be performed and the assignment of tasks to servers for processing. In general, the scheduling problem assumes a set of resources and a set of consumers serviced by those resources according to a certain policy. The nature of the consumers and resources as well as the constraints on them affect the search for an efficient policy for managing the way consumers access and use the resources to optimize some desired performance measure. Thus, a scheduling system comprises a set of consumers, a set of resources, and a scheduling policy. A task in a program, a job in a factory, and a customer in a bank are examples of consumers. A processing element in a computer system, a machine in a factory, and a teller in a bank are examples of resources. First come, first served is an example of a scheduling policy. Scheduling policy performance varies with circumstances. While the equitable first-come, first-served policy is appropriate in a bank, it may not be the best policy for jobs on a factory floor or tasks in a computer system. This article addresses the task scheduling problem in many of its variations and surveys the major solutions. The scheduling techniques we discuss might be used by a compiler writer to optimize the code that comes out of a parallelizing compiler. The compiler would produce grains of sequential code, and the optimizer would schedule these grains such that the program runs in the shortest time. Another use of these techniques is in the design of high-performance systems. A designer might want to construct a parallel application that runs in the shortest time possible on some arbitrary system. We believe the methods presented here can also be adapted to other (related) resource allocation problems of computing. Suppose a team of programmers wants to divide a programming task into subsystems. Let’s say each programmer depends on some other programmer(s) for interface specifications; otherwise, the programmers work in parallel. Thus, the team can be modeled as a parallel processor, and the program to be written can be modeled as parallel tasks. The scheduler now tries to find the assignment of subsystems to programmers that will let the team finish the program in the shortest time. This article concerns scheduling program tasks on parallel and distributed systems. The tasks are the consumers, and they will be represented through the use of directed graphs called task graphs. The processing elements are the resources, and their interconnection networks can be represented through the use of undirected graphs. The scheduler generates a schedule in the form of a timing diagram called the Gantt chart, which is